问题描述

一家公司正在改变它的经营方式，因此它的员工需求预计也会发生变化。

通过购买新机器，预计对非熟练劳动力的需求将减少，而对熟练和半熟练劳动力的需求将增加。此外，由于预计明年将出现的经济放缓，销售预期下降，预计将进一步减少所有类别的劳动力需求。

未来三年的劳动力需求预测如下:

	Unskilled	Semi-skilled	Skilled
Current Strength	2000	1500	1000
Year 1	1000	1400	1000
Year 2	500	2000	1500
Year 3	0	2500	2000

公司需要在未来三年每年确定以下事项:

• 招聘
• 再培训
• 裁员(冗余)
• 兼职和全职员工

值得注意的是，劳动力每年都一定程度的自然流失。新员工入职后第一年的流失率相对较高，随后几年的流失率相对较低。预期的流失率如下:

	Unskilled (%)	Semi-skilled (%)	Skilled (%)
$< 1$ year of service	25	20	10
$\geq 1$ year of service	10	5	5

目前所有的员工都在公司工作了至少一年。

招聘

每年，可以从公司外部雇佣有限数量的每个级别的员工，具体如下:

Unskilled	Semi-skilled	Skilled
500	800	500

再培训

每年可以培训多达200名非技术工人，使他们成为半技术工人。每个工人培训花费400美元。

此外，也可以对半熟练工人进行培训，使他们成为熟练工人。然而，这一数字不能超过当前熟练劳动力的25%，而且培训成本为每个工人500美元。

最后，工人也会被降级。但是，50%被降级的员工将离开公司，在自然流失率的基础上增加员工流失。

裁员

每名被解雇的工人可领取离职补偿金，每名非熟练工人领取200元，每名半熟练或熟练工人领取500元。

冗余员工

该公司允许一年至多有150名冗余工人，但这将导致每年一名多出的雇员产生以下额外成本。

Unskilled	Semi-skilled	Skilled
1500	2000	3000

兼职工人

每个技能级别最多可分配50名员工从事兼职工作。一年每名雇员的费用如下:

Unskilled	Semi-skilled	Skilled
500	400	400

注意

• 兼职员工的工作效率是全职员工的一半。
• 如果公司的目标是尽量减少裁员，他们应该采取什么计划来实现这个目标?
• 如果他们的目标是将成本降至最低，他们能进一步降低多少成本?
• 他们如何确定每项工作每年可能节省的开支?

---

数学模型

集合及索引

• $t \in \text{Years}=\{1,2,3\}$: 年份集合
• $s \in \text{Skills}=\{s_1: \text{unskilled},s_2: \text{semi_skilled},s_3: \text{skilled}\}$: 技能等级集合

参数

• $\text{rookie_attrition} \in [0,1] \subset \mathbb{R}^+$: 入职一年内员工流失的比例
• $\text{veteran_attrition} \in [0,1] \subset \mathbb{R}^+$: 入职超过一年员工流失的比例
• $\text{demoted_attrition} \in [0,1] \subset \mathbb{R}^+$: 被降职后员工六十的比例
• $\text{parttime_cap} \in [0,1] \subset \mathbb{R}^+$: 相比于全职员工，兼职员工的生产力
• $\text{max_train_unskilled} \in \mathbb{N}$: 每一年最多可培训的非技术工人人数
• $\text{max_train_semiskilled} \in [0,1] \subset \mathbb{R}^+$: 每一年最多可培训的半技术工人人数
• $\text{max_parttime} \in \mathbb{N}$: 每年每种技能等级最多可雇佣的兼职员工人数
• $\text{max_overmanning} \in \mathbb{N}$: 每年允许的最多的冗员数量
• $\text{max_hiring}_s \in \mathbb{N}$:每年可雇佣的技能等级 $s$ 员工数量
• $\text{training_cost}_s \in \mathbb{R}^+$:将一个技能$s$等级员工培训为下一等级的费用
• $\text{layoff_cost}_s \in \mathbb{R}^+$:解雇一名技能等级$s$员工的费用
• $\text{parttime_cost}_s \in \mathbb{R}^+$: 雇佣一名等级 $s$ 的兼职员工的费用
• $\text{overmanning_cost}_s \in \mathbb{R}^+$: 一名技能等级 $s$的冗余员工的年花费用
• $\text{curr_workforce}_s \in \mathbb{N}$: 现有技能等级$s$ 的员工数量
• $\text{demand}_{t,s} \in \mathbb{N}$: 年份$t$技能等级$s$的员工数量

决策变量

• $\text{hire}_{t,s} \in [0,\text{max_hiring}_s] \subset \mathbb{R}^+$: 要在年份$t$雇佣技能$s$的正式员工人数
• $\text{part_time}_{t,s} \in [0,\text{max_parttime}] \subset \mathbb{R}^+$: 要在年份$t$雇佣技能$s$的兼职员工人数
• $\text{workforce}_{t,s} \in \mathbb{R}^+$: 年份$t$可招到的技能等级$s$的数量
• $\text{layoff}_{t,s} \in \mathbb{R}^+$: 年份$t$解雇的技能 $s$ 的数量
• $\text{excess}_{t,s} \in \mathbb{R}^+$: 年份$t$的技能等级为$s$的冗员数量
• $\text{train}_{t,s,s'} \in \mathbb{R}^+$: 年份$t$从等级$s$ 再培训到等级$s'$ 的员工数量

目标函数

• 解雇人数: 最小化计划期内解雇的员工人数 $$ \begin{equation} \text{Minimize} \quad Z = \sum_{t \in \text{Years}}\sum_{s \in \text{Skills}}{\text{layoff}_{t,s}} \end{equation} $$
• 费用: 最小化计划期内再培训、兼职、解雇、冗员的数量. $$ \begin{equation} \text{Minimize} \quad W = \sum_{t \in \text{Years}}{\{\text{training_cost}_{s_1}*\text{train}_{t,s1,s2} + \text{training_cost}_{s_2}*\text{train}_{t,s2,s3}\}} \end{equation} $$

$$ \begin{equation} + \sum_{t \in \text{Years}}\sum_{s \in \text{Skills}}{\{\text{parttime_cost}*\text{part_time}_{t,s} + \text{layoff_cost}_s*\text{layoff}_{t,s} + \text{overmanning_cost}_s*\text{excess}_{t,s}\}} \end{equation} $$

约束条件

• 初始均衡: 年份 $t=1$ 技能等级$s$ 的员工数量等于上一年招聘、晋升、降级（降级流失之后）减去解雇和技能等级变化的人工数量。

$$ \begin{aligned} \text{workforce}_{1,s} &= (1-\text{veteran_attrition}_s)*\text{curr_workforce} + (1-\text{rookie_attrition}_s)*\text{hire}_{1,s} \\ &+ \sum_{s' \in \text{Skills} | s' < s}{\{(1-\text{veteran_attrition})*\text{train}_{1,s',s} - \text{train}_{1,s,s'}\}} \\ &+ \sum_{s' \in \text{Skills} | s' > s}{\{(1-\text{demoted_attrition})*\text{train}_{1,s',s} - \text{train}_{1,s,s'}\}} - \text{layoff}_{1,s} \\ \qquad \forall s \in \text{Skills} \end{aligned} $$

• 数量均衡: 劳动力$s$可在年度$t > 1$等于前一年的劳动力，最近的雇员，晋升和降级的工人(在考虑了减员后)，减去裁员和转移的工人。

$$ \begin{aligned} \text{workforce}_{t,s} &= (1-\text{veteran_attrition}_s)*\text{workforce}_{t-1,s} + (1-\text{rookie_attrition}_s)*\text{hire}_{t,s} \\ &+ \sum_{s' \in \text{Skills} | s' < s}{\{(1-\text{veteran_attrition})*\text{train}_{t,s',s} - \text{train}_{t,s,s'}\}}\\ &+ \sum_{s' \in \text{Skills} | s' > s}{\{(1-\text{demotion_attrition})*\text{train}_{t,s',s} - \text{train}_{t,s,s'}\}} - \text{layoff}_{t,s} \quad \forall (t > 1,s) \in \text{Years} \times \text{Skills} \end{aligned} $$

• 非技术性员工的培训: 在$t$年受训的非技术工人不得超过最大的培训数量。非技术工人不能立即转变为技术工人。

$$ \begin{aligned} \text{train}_{t,s_1,s_2} \leq 200 \quad \forall t \in \text{Years}\\ \text{train}_{t,s_1,s_3} = 0 \quad \forall t \in \text{Years} \end{aligned} $$

• 半技术性员工的培训: 在$t$年受训的半技术工人不得超过最大的培训数量。
  $$ \begin{equation} \text{train}_{t,s_2,s_3} \leq 0.25*\text{available}_{t,s_3} \quad \forall t \in \text{Years} \end{equation} $$

• 冗员: 在$t$年的冗余员工数量不得超过最大的数量。
  $$ \begin{equation} \sum_{s \in \text{Skills}}{\text{excess}_{t,s}} \leq \text{max_overmanning} \quad \forall t \in \text{Years} \end{equation} $$

• 需求量: 可用劳动力$s$年$t$等于所需工人人数加上多余工人和兼职工人。 $$ \begin{equation} \text{available}_{t,s} = \text{demand}_{t,s} + \text{excess}_{t,s} + \text{parttime_cap}*\text{part_time}_{t,s} \quad \forall (t,s) \in \text{Years} \times \text{Skills} \end{equation} $$

参考资料

• H. Paul Williams, Model Building in Mathematical Programming, fifth edition (Page 255-256, 354-356)

---

Python Implementation

import numpy as np
import pandas as pd

import pulp as lp

Input Data

We define all the input data of the model.

# Parameters

years = [1, 2, 3]
skills = ['s1', 's2', 's3']

curr_workforce = {'s1': 2000, 's2': 1500, 's3': 1000}
demand = {
    (1, 's1'): 1000,
    (1, 's2'): 1400,
    (1, 's3'): 1000,
    (2, 's1'): 500,
    (2, 's2'): 2000,
    (2, 's3'): 1500,
    (3, 's1'): 0,
    (3, 's2'): 2500,
    (3, 's3'): 2000
}
rookie_attrition = {'s1': 0.25, 's2': 0.20, 's3': 0.10}
veteran_attrition = {'s1': 0.10, 's2': 0.05, 's3': 0.05}
demoted_attrition = 0.50
max_hiring = {
    (1, 's1'): 500,
    (1, 's2'): 800,
    (1, 's3'): 500,
    (2, 's1'): 500,
    (2, 's2'): 800,
    (2, 's3'): 500,
    (3, 's1'): 500,
    (3, 's2'): 800,
    (3, 's3'): 500
}
max_overmanning = 150
max_parttime = 50
parttime_cap = 0.50
max_train_unskilled = 200
max_train_semiskilled = 0.25

training_cost = {'s1': 400, 's2': 500}
layoff_cost = {'s1': 200, 's2': 500, 's3': 500}
parttime_cost = {'s1': 500, 's2': 400, 's3': 400}
overmanning_cost = {'s1': 1500, 's2': 2000, 's3': 3000}

manpower = lp.LpProblem(name='Manpower_planning',sense=lp.LpMinimize)

hire = lp.LpVariable.dicts(name="Hire",indexs=[(t,s) for t in years for s in skills],lowBound=0,cat='Integer')
part_time = lp.LpVariable.dicts(name="Part_time",indexs=[(t,s) for t in years for s in skills], lowBound=0,upBound=max_parttime,cat='Integer')
workforce = lp.LpVariable.dicts(name="Available",indexs=[(t,s) for t in years for s in skills], lowBound=0,cat="Integer")
layoff = lp.LpVariable.dicts(name="Layoff",indexs=[(t,s) for t in years for s in skills], lowBound=0,cat="Integer")
excess = lp.LpVariable.dicts(name="Overmanned",indexs=[(t,s) for t in years for s in skills], lowBound=0,cat="Integer")
train = lp.LpVariable.dicts(name="Train",indexs=[(t,s,s1) for t in years for s in skills for s1 in skills], lowBound=0,cat="Integer")

for year in years:
    for skill in skills:
        manpower += hire[year,skill]<=max_hiring[(year,skill)]

#0.1 Objective Function: Minimize layoffs
obj1 = lp.lpSum(layoff[t,s] for t in years for s in skills)
manpower += obj1

#1.1 & 1.2 Balance
for year in years:
    for level in skills:
        if year == 1:
            manpower += workforce[year, level] == (1-veteran_attrition[level])*(curr_workforce[level])+ (1-rookie_attrition[level])*hire[year, level] + lp.lpSum((1- veteran_attrition[level])* train[year, level2, level]-train[year, level, level2] for level2 in skills if level2 < level)+ lp.lpSum((1- demoted_attrition)* train[year, level2, level] -train[year, level, level2] for level2 in skills if level2 > level)
            - layoff[year, level]
        else:
            manpower += workforce[year, level] == (1-veteran_attrition[level])*(workforce[year-1, level])+ (1-rookie_attrition[level])*hire[year, level] + lp.lpSum((1- veteran_attrition[level])* train[year, level2, level]-train[year, level, level2] for level2 in skills if level2 < level)+ lp.lpSum((1- demoted_attrition)* train[year, level2, level] -train[year, level, level2] for level2 in skills if level2 > level)
            - layoff[year, level]

由于能力限制，每年只有200名工人可以从非技术培训再培训为半技术培训。而且，没有人能在一年内从不熟练变成熟练。

#2.1 & 2.2  Unskilled training
for year in years:
    manpower += train[year, 's1', 's2'] <= max_train_unskilled 
    manpower += train[year, 's1', 's3'] == 0 

将半技能工人再培训为熟练工人的人数不得超过当时熟练劳动力的四分之一

#3. Semi-skilled training
for year in years:
    manpower += train[year,'s2', 's3'] <= max_train_semiskilled * workforce[year,'s3']

编制过剩的限制确保所有技能级别的人员在一年内的编制过剩总数不超过150人。

#4. Overmanning
for year in years:
    manpower += lp.lpSum(excess[year, s] for s in skills) <= max_overmanning

确保每个级别和每年的工人数量等于所需的工人数量加上正式员工数量和兼职工作的工人数量。

#5. Demand
for year in years:
    for level in skills:
        manpower+=workforce[year, level] ==demand[year,level] + excess[year, level] + parttime_cap * part_time[year, level]

• 第一个目标是尽量减少下岗总人数。
• 第二个备选目标是尽量减少所有受雇工人的总费用和再培训费用

manpower.solve()

-1

Analysis

The minimum number of layoffs is 841.80. The optimal policies to achieve this minimum number of layoffs are given below.

Hiring Plan

This plan determines the number of new workers to hire at each year of the planning horizon (rows) and each skill level (columns). For example, at year 2 we are going to hire 649.3 Semi-skilled workers.

rows = years.copy()
columns = skills.copy()
hire_plan = pd.DataFrame(columns=columns, index=rows, data=0.0)

for year in years:
    for level in skills:
        if (abs(lp.value(hire[year, level]))) > 1e-6:
            hire_plan.loc[year, level] = np.round(lp.value(hire[year, level]), 1)
hire_plan

	s1	s2	s3
1	0.0	0.0	0.0
2	0.0	800.0	500.0
3	0.0	2374.3	500.0

Training and Demotions Plan

This plan defines the number of workers to promote by training (or demote) at each year of the planning horizon. For example, in year 1 we are going to demote 168.4 skilled (s3) workers to the level of semi-skilled (s2).

rows = years.copy()
columns = ['{0} to {1}'.format(level1, level2) for level1 in skills for level2 in skills if level1 != level2]
train_plan = pd.DataFrame(columns=columns, index=rows, data=0.0)

for year in years:
    for level1 in skills:
        for level2 in skills:
            if level1 != level2:
                col = '{0} to {1}'.format(level1, level2)
                if (abs(lp.value(train[year, level1, level2])) > 1e-6):
                    train_plan.loc[year, col] = np.round(lp.value(train[year, level1, level2]), 1)
train_plan

	s1 to s2	s1 to s3	s2 to s1	s2 to s3	s3 to s1	s3 to s2
1	200.0	0.0	885.9	256.2	0.0	168.4
2	200.0	0.0	0.0	0.0	0.0	1281.6
3	200.0	0.0	0.0	1489.5	0.0	0.0

Layoffs Plan

This plan determines the number of workers to layoff of each skill level at each year of the planning horizon. For example, we are going to layoff 232.5 Unskilled workers in year 3.

rows = years.copy()
columns = skills.copy()
layoff_plan = pd.DataFrame(columns=columns, index=rows, data=0.0)

for year in years:
    for level in skills:
        if (abs(lp.value(layoff[year, level])) > 1e-6):
            layoff_plan.loc[year, level] = np.round(lp.value(layoff[year, level]), 1)
layoff_plan

	s1	s2	s3
1	0.0	0.0	0.0
2	0.0	0.0	0.0
3	0.0	0.0	0.0

Part-time Plan

This plan defines the number of part-time workers of each skill level working at each year of the planning horizon. For example, in year 1, we have 50 part-time skilled workers.

rows = years.copy()
columns = skills.copy()
parttime_plan = pd.DataFrame(columns=columns, index=rows, data=0.0)

for year, level in part_time.keys():
    if (abs(lp.value(part_time[year, level])) > 1e-6):
        parttime_plan.loc[year, level] = np.round(lp.value(part_time[year, level]), 1)
parttime_plan

	s1	s2	s3
1	50.0	50.0	50.0
2	1977.3	0.0	-2715.8
3	2249.6	0.0	0.0

Overmanning Plan

This plan determines the number of excess workers of each skill level working at each year of the planning horizon. For example, we have 150 Unskilled excess workers in year 3.

rows = years.copy()
columns = skills.copy()
excess_plan = pd.DataFrame(columns=columns, index=rows, data=0.0)

for year, level in excess.keys():
    if (abs(lp.value(excess[year, level])) > 1e-6):
        excess_plan.loc[year, level] = np.round(lp.value(excess[year, level]), 1)
excess_plan

	s1	s2	s3
1	1018.0	-868.0	0.0
2	150.0	0.0	0.0
3	150.0	0.0	0.0

References

H. Paul Williams, Model Building in Mathematical Programming, fifth edition (Page 255-256, 354-356)